/**
 * 访问统计API接口
 */

import dayjs from 'dayjs';

// 访问统计数据接口
export interface AccessStats {
  /** 今日访问量 */
  todayVisits: number;
  /** 昨日访问量 */
  yesterdayVisits: number;
  /** 本周访问量 */
  weekVisits: number;
  /** 上周访问量 */
  lastWeekVisits: number;
  /** 本月访问量 */
  monthVisits: number;
  /** 活跃用户数 */
  activeUsers: number;
  /** 页面浏览量 */
  pageViews: number;
  /** 最后更新时间 */
  updateTime: string;
}

// 访问趋势数据接口
export interface AccessTrend {
  /** 日期 */
  date: string;
  /** 访问量 */
  visits: number;
  /** 独立访客 */
  uniqueVisitors: number;
  /** 页面浏览量 */
  pageViews: number;
}

// 访问趋势图表数据
export interface AccessTrendChart {
  /** 日期数组 */
  dates: string[];
  /** 访问量数据 */
  visits: number[];
  /** 独立访客数据 */
  uniqueVisitors: number[];
  /** 页面浏览量数据 */
  pageViews: number[];
}

// 地域分布数据接口
export interface RegionStats {
  /** 地区名称 */
  region: string;
  /** 访问量 */
  visits: number;
  /** 占比 */
  percentage: number;
}

// 设备类型统计接口
export interface DeviceStats {
  /** 设备类型 */
  deviceType: string;
  /** 访问量 */
  visits: number;
  /** 占比 */
  percentage: number;
}

// 热门页面接口
export interface PopularPage {
  /** 页面路径 */
  path: string;
  /** 页面标题 */
  title: string;
  /** 访问量 */
  visits: number;
  /** 平均停留时间（秒） */
  avgDuration: number;
}

// 浏览器统计接口
export interface BrowserStats {
  /** 浏览器名称 */
  browser: string;
  /** 访问量 */
  visits: number;
  /** 占比 */
  percentage: number;
}

/**
 * 生成模拟访问数据
 */
function generateMockVisitData(baseValue: number, variance: number = 0.3): number {
  const randomFactor = 1 + (Math.random() - 0.5) * variance;
  return Math.floor(baseValue * randomFactor);
}

/**
 * 获取最近7天的访问趋势数据
 */
export async function getAccessTrend(): Promise<AccessTrendChart> {
  try {
    // 这里应该调用真实的后端API
    // const response = await requestClient.get('/monitor/access/trend');
    // return response.data;
    
    // 临时使用模拟数据
    const dates: string[] = [];
    const visits: number[] = [];
    const uniqueVisitors: number[] = [];
    const pageViews: number[] = [];
    
    // 生成最近7天的数据
    for (let i = 6; i >= 0; i--) {
      const date = dayjs().subtract(i, 'day');
      dates.push(date.format('MM-DD'));
      
      // 生成模拟数据（工作日访问量较高）
      const isWeekend = date.day() === 0 || date.day() === 6;
      const baseVisits = isWeekend ? 800 : 1200;
      const baseUniqueVisitors = isWeekend ? 300 : 500;
      const basePageViews = isWeekend ? 2000 : 3500;
      
      visits.push(generateMockVisitData(baseVisits));
      uniqueVisitors.push(generateMockVisitData(baseUniqueVisitors));
      pageViews.push(generateMockVisitData(basePageViews));
    }
    
    return {
      dates,
      visits,
      uniqueVisitors,
      pageViews,
    };
  } catch (error) {
    console.error('获取访问趋势失败:', error);
    // 返回默认数据
    return {
      dates: ['12-29', '12-30', '12-31', '01-01', '01-02', '01-03', '01-04'],
      visits: [800, 1200, 1100, 600, 900, 1300, 1150],
      uniqueVisitors: [300, 500, 450, 250, 380, 520, 480],
      pageViews: [2000, 3500, 3200, 1800, 2600, 3800, 3400],
    };
  }
}

/**
 * 获取访问统计概览数据
 */
export async function getAccessStats(): Promise<AccessStats> {
  try {
    // 这里应该调用真实的后端API
    // const response = await requestClient.get('/monitor/access/stats');
    // return response.data;
    
    // 临时使用模拟数据
    const today = dayjs();
    const isWeekend = today.day() === 0 || today.day() === 6;
    
    // 根据是否周末调整基础数据
    const todayBase = isWeekend ? 800 : 1200;
    const yesterdayBase = isWeekend ? 900 : 1100;
    
    return {
      todayVisits: generateMockVisitData(todayBase),
      yesterdayVisits: generateMockVisitData(yesterdayBase),
      weekVisits: generateMockVisitData(7000),
      lastWeekVisits: generateMockVisitData(6800),
      monthVisits: generateMockVisitData(25000),
      activeUsers: generateMockVisitData(1500),
      pageViews: generateMockVisitData(15000),
      updateTime: new Date().toISOString(),
    };
  } catch (error) {
    console.error('获取访问统计失败:', error);
    // 返回默认数据
    return {
      todayVisits: 1200,
      yesterdayVisits: 1100,
      weekVisits: 7000,
      lastWeekVisits: 6800,
      monthVisits: 25000,
      activeUsers: 1500,
      pageViews: 15000,
      updateTime: new Date().toISOString(),
    };
  }
}

/**
 * 获取实时访问数据（用于定时刷新）
 */
export async function getRealtimeAccessData(): Promise<{
  currentOnline: number;
  todayVisits: number;
  growth: number;
}> {
  try {
    // 这里应该调用真实的后端API
    // const response = await requestClient.get('/monitor/access/realtime');
    // return response.data;
    
    // 临时使用模拟数据
    return {
      currentOnline: Math.floor(Math.random() * 100) + 50, // 50-150人在线
      todayVisits: generateMockVisitData(1200),
      growth: Math.floor((Math.random() - 0.5) * 20), // -10% 到 +10% 的增长率
    };
  } catch (error) {
    console.error('获取实时访问数据失败:', error);
    return {
      currentOnline: 80,
      todayVisits: 1200,
      growth: 5,
    };
  }
}

/**
 * 获取地域分布统计
 */
export async function getRegionStats(): Promise<RegionStats[]> {
  try {
    // 模拟地域数据
    const regions = [
      { region: '北京', base: 2500 },
      { region: '上海', base: 2200 },
      { region: '广东', base: 1800 },
      { region: '浙江', base: 1200 },
      { region: '江苏', base: 1000 },
      { region: '其他', base: 800 },
    ];
    
    const totalVisits = regions.reduce((sum, region) => sum + generateMockVisitData(region.base), 0);
    
    return regions.map(region => {
      const visits = generateMockVisitData(region.base);
      return {
        region: region.region,
        visits,
        percentage: Number(((visits / totalVisits) * 100).toFixed(1)),
      };
    });
  } catch (error) {
    console.error('获取地域统计失败:', error);
    return [];
  }
}

/**
 * 获取设备类型统计
 */
export async function getDeviceStats(): Promise<DeviceStats[]> {
  try {
    const devices = [
      { deviceType: '桌面端', base: 4500 },
      { deviceType: '移动端', base: 3200 },
      { deviceType: '平板', base: 800 },
    ];
    
    const totalVisits = devices.reduce((sum, device) => sum + generateMockVisitData(device.base), 0);
    
    return devices.map(device => {
      const visits = generateMockVisitData(device.base);
      return {
        deviceType: device.deviceType,
        visits,
        percentage: Number(((visits / totalVisits) * 100).toFixed(1)),
      };
    });
  } catch (error) {
    console.error('获取设备统计失败:', error);
    return [];
  }
}

/**
 * 获取热门页面统计
 */
export async function getPopularPages(): Promise<PopularPage[]> {
  try {
    const pages = [
      { path: '/dashboard', title: '工作台', base: 1500 },
      { path: '/system/user', title: '用户管理', base: 1200 },
      { path: '/monitor/online', title: '在线用户', base: 800 },
      { path: '/system/role', title: '角色管理', base: 600 },
      { path: '/tool/gen', title: '代码生成', base: 400 },
    ];
    
    return pages.map(page => ({
      path: page.path,
      title: page.title,
      visits: generateMockVisitData(page.base),
      avgDuration: Math.floor(Math.random() * 180) + 30, // 30-210秒
    }));
  } catch (error) {
    console.error('获取热门页面失败:', error);
    return [];
  }
}

/**
 * 获取浏览器统计
 */
export async function getBrowserStats(): Promise<BrowserStats[]> {
  try {
    const browsers = [
      { browser: 'Chrome', base: 5000 },
      { browser: 'Firefox', base: 1200 },
      { browser: 'Safari', base: 800 },
      { browser: 'Edge', base: 600 },
      { browser: '其他', base: 400 },
    ];
    
    const totalVisits = browsers.reduce((sum, browser) => sum + generateMockVisitData(browser.base), 0);
    
    return browsers.map(browser => {
      const visits = generateMockVisitData(browser.base);
      return {
        browser: browser.browser,
        visits,
        percentage: Number(((visits / totalVisits) * 100).toFixed(1)),
      };
    });
  } catch (error) {
    console.error('获取浏览器统计失败:', error);
    return [];
  }
}